package br.edu.faculdadeprojecao.mb;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;

import org.primefaces.context.RequestContext;

import br.edu.faculdadeprojecao.DAO.AtividadeCientificaDAO;
import br.edu.faculdadeprojecao.DAO.EnderecoDAO;
import br.edu.faculdadeprojecao.DAO.ExperienciaDocenteDAO;
import br.edu.faculdadeprojecao.DAO.ExperienciaProfissionalDAO;
import br.edu.faculdadeprojecao.DAO.FormacaoDAO;
import br.edu.faculdadeprojecao.DAO.PublicacaoDAO;
import br.edu.faculdadeprojecao.DAO.TelefoneDAO;
import br.edu.faculdadeprojecao.DAO.TipoFormacaoDAO;
import br.edu.faculdadeprojecao.enuns.TipoTelefone;
import br.edu.faculdadeprojecao.modelo.AtividadeCientifica;
import br.edu.faculdadeprojecao.modelo.Endereco;
import br.edu.faculdadeprojecao.modelo.ExperienciaDocente;
import br.edu.faculdadeprojecao.modelo.ExperienciaProfissional;
import br.edu.faculdadeprojecao.modelo.Formacao;
import br.edu.faculdadeprojecao.modelo.Publicacao;
import br.edu.faculdadeprojecao.modelo.Telefone;
import br.edu.faculdadeprojecao.modelo.TipoFormacao;
import br.edu.faculdadeprojecao.modelo.Usuario;

@ViewScoped
@ManagedBean
public class FichaDocenteBean implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	private Usuario usuario;
	private Endereco endereco = new Endereco();
	private List<Formacao> formacoes;
	private Formacao formacao = new Formacao();
	private ExperienciaProfissional experienciaProfissional = new ExperienciaProfissional();
	private List<ExperienciaProfissional> experienciasProfissionais;
	private ExperienciaDocente experienciaDocente = new ExperienciaDocente();
	private List<ExperienciaDocente> experienciasDocentes;
	private Telefone telefone = new Telefone();
	private Publicacao publicacao = new Publicacao();
	private List<Publicacao> publicacoes;
	private AtividadeCientifica atividadeCientifica = new AtividadeCientifica();
	private List<AtividadeCientifica> atividadesCientificas;
	private List<TipoFormacao> tipoFormacoes;
	private String tipoFormacaoSelecionado;
	private Endereco enderecoUsuario = new Endereco();
	private List<Telefone> telefones;

	public TipoTelefone[] getTiposTelefone() {
		return TipoTelefone.values();
	}

	public void limparAtividadeCientifica() {

		this.atividadeCientifica = new AtividadeCientifica();
		this.atividadesCientificas = null;

	}

	public void limparPublicacao() {
		this.publicacao = new Publicacao();
		this.publicacoes = null;
	}

	public void limparTelefones() {
		this.telefones = null;
		this.telefone = new Telefone();
	}

	public void limparFormacao() {
		this.formacao = new Formacao();
		this.formacoes = null;
		this.setTipoFormacaoSelecionado(null);
	}

	public void limparEndereco() {
		this.endereco = new Endereco();
		this.enderecoUsuario = new Endereco();
	}

	public void limparExperienciaProfissional() {
		this.experienciaProfissional = new ExperienciaProfissional();
		this.experienciasProfissionais = null;
	}

	public void limparExperienciasDocentes() {
		this.experienciasDocentes = null;
		this.experienciaDocente = new ExperienciaDocente();
	}

	public Usuario getUsuario() {
		return usuario;
	}

	public void setUsuario(Usuario usuario) {
		this.usuario = usuario;
	}

	public Endereco getEndereco() {
		return endereco;
	}

	public void setEndereco(Endereco endereco) {
		this.endereco = endereco;
	}

	public List<Formacao> getFormacoes() {

		if (formacoes == null) {
			FormacaoDAO dao = new FormacaoDAO();
			formacoes = dao.formacaoPorUsuario(usuario);
		}
		return formacoes;
	}

	public void setFormacoes(List<Formacao> formacoes) {
		this.formacoes = formacoes;
	}

	public ExperienciaProfissional getExperienciaProfissional() {
		return experienciaProfissional;
	}

	public void setExperienciaProfissional(
			ExperienciaProfissional experienciaProfissional) {
		this.experienciaProfissional = experienciaProfissional;
	}

	public ExperienciaDocente getExperienciaDocente() {
		return experienciaDocente;
	}

	public void setExperienciaDocente(ExperienciaDocente experienciaDocente) {
		this.experienciaDocente = experienciaDocente;
	}

	public Telefone getTelefone() {
		return telefone;
	}

	public void setTelefone(Telefone telefone) {
		this.telefone = telefone;
	}

	public Publicacao getPublicacao() {
		return publicacao;
	}

	public void setPublicacao(Publicacao publicacao) {
		this.publicacao = publicacao;
	}

	public AtividadeCientifica getAtividadeCientifica() {
		return atividadeCientifica;
	}

	public void setAtividadeCientifica(AtividadeCientifica atividadeCientifica) {
		this.atividadeCientifica = atividadeCientifica;
	}

	public Formacao getFormacao() {
		return formacao;
	}

	public void setFormacao(Formacao formacao) {
		setTipoFormacaoSelecionado(formacao.getTipoFormacao().getDescricao());
		this.formacao = formacao;
	}

	public List<String> getTipoFormacoes() {
		if (tipoFormacoes == null) {
			TipoFormacaoDAO dao = new TipoFormacaoDAO();
			setTipoFormacoes(dao.TipoFormacoes());
		}
		List<String> tipoF = new ArrayList<String>();
		for (TipoFormacao formacao : tipoFormacoes) {
			tipoF.add(formacao.getDescricao());
		}

		return tipoF;
	}

	public void setTipoFormacoes(List<TipoFormacao> tipoFormacoes) {
		this.tipoFormacoes = tipoFormacoes;
	}

	public void gravarFormacao(ActionEvent actionEvent) {
		FormacaoDAO formacaoDAO = new FormacaoDAO();
		TipoFormacaoDAO tipoFormacaoDAO = new TipoFormacaoDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			formacao.setTipoFormacao((tipoFormacaoDAO
					.buscaPorNome(tipoFormacaoSelecionado)));
			formacao.setUsuario(usuario);
			formacaoDAO.cadastrar(formacao);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Gravado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao gravar", null);
		}
		formacoes = null;
		formacao = new Formacao();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void alterarFormacao(ActionEvent actionEvent) {
		FormacaoDAO formacaoDAO = new FormacaoDAO();
		TipoFormacaoDAO tipoFormacaoDAO = new TipoFormacaoDAO();

		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			formacao.setTipoFormacao((tipoFormacaoDAO
					.buscaPorNome(tipoFormacaoSelecionado)));
			formacaoDAO.atualizar(formacao);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Alterado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao alterar", null);
		}
		limparFormacao();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void removerFormacao() {

		FormacaoDAO dao = new FormacaoDAO();
		try {
			dao.delete(formacao);
			limparFormacao();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public String getTipoFormacaoSelecionado() {
		return tipoFormacaoSelecionado;
	}

	public void setTipoFormacaoSelecionado(String tipoFormacaoSelecionado) {
		this.tipoFormacaoSelecionado = tipoFormacaoSelecionado;
	}

	public List<ExperienciaDocente> getExperienciasDocentes() {
		if (experienciasDocentes == null) {
			ExperienciaDocenteDAO dao = new ExperienciaDocenteDAO();
			setExperienciasDocentes(dao.experienciasPorUsuario(usuario));
		}
		return experienciasDocentes;
	}

	public void setExperienciasDocentes(
			List<ExperienciaDocente> experienciasDocentes) {
		this.experienciasDocentes = experienciasDocentes;
	}

	public void gravarExperienciaDocente(ActionEvent actionEvent) {
		ExperienciaDocenteDAO experienciaDocenteDAO = new ExperienciaDocenteDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			experienciaDocente.setUsuario(usuario);
			experienciaDocenteDAO.salva(experienciaDocente);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Gravado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao gravar", null);
		}
		limparExperienciasDocentes();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void alterarExperienciaDocente(ActionEvent actionEvent) {
		ExperienciaDocenteDAO experienciaDocenteDAO = new ExperienciaDocenteDAO();

		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			experienciaDocenteDAO.altera(experienciaDocente);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Alterado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao alterar", null);
		}
		limparExperienciasDocentes();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void removerExperienciaDocente() {

		ExperienciaDocenteDAO experienciaDocenteDAO = new ExperienciaDocenteDAO();
		try {
			experienciaDocenteDAO.delete(experienciaDocente);
			limparExperienciasDocentes();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public List<ExperienciaProfissional> getExperienciasProfissionais() {
		if (experienciasProfissionais == null) {
			ExperienciaProfissionalDAO dao = new ExperienciaProfissionalDAO();
			setExperienciasProfissionais(dao
					.experienciasProfissionaisPorUsuario(usuario));
		}
		return experienciasProfissionais;
	}

	public void setExperienciasProfissionais(
			List<ExperienciaProfissional> experienciasProfissionais) {
		this.experienciasProfissionais = experienciasProfissionais;
	}

	public void gravarExperienciaProfissional(ActionEvent actionEvent) {
		ExperienciaProfissionalDAO experienciaProfissionalDAO = new ExperienciaProfissionalDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			experienciaProfissional.setUsuario(usuario);
			experienciaProfissionalDAO.salva(experienciaProfissional);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Gravado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao gravar", null);
		}
		limparExperienciaProfissional();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void alterarExperienciaProfissional(ActionEvent actionEvent) {
		ExperienciaProfissionalDAO experienciaProfissionalDAO = new ExperienciaProfissionalDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			experienciaProfissionalDAO.altera(experienciaProfissional);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Alterado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao alterar", null);
		}
		limparExperienciaProfissional();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void removerExperienciaProfissional() {

		ExperienciaProfissionalDAO experienciaProfissionalDAO = new ExperienciaProfissionalDAO();
		try {
			experienciaProfissionalDAO.delete(experienciaProfissional);
			limparExperienciaProfissional();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public List<AtividadeCientifica> getAtividadesCientificas() {
		if (atividadesCientificas == null) {
			AtividadeCientificaDAO atividadeCientificaDAO = new AtividadeCientificaDAO();
			setAtividadesCientificas(atividadeCientificaDAO
					.atividadesCientificasPorUsuario(usuario));
		}
		return atividadesCientificas;
	}

	public void setAtividadesCientificas(
			List<AtividadeCientifica> atividadesCientificas) {
		this.atividadesCientificas = atividadesCientificas;
	}

	public void gravarAtividadeCientifica(ActionEvent actionEvent) {
		AtividadeCientificaDAO atividadeCientificaDAO = new AtividadeCientificaDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			atividadeCientifica.setUsuario(usuario);
			atividadeCientificaDAO.salva(atividadeCientifica);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Gravado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao gravar", null);
		}
		limparAtividadeCientifica();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void alterarAtividadeCientifica(ActionEvent actionEvent) {
		AtividadeCientificaDAO atividadeCientificaDAO = new AtividadeCientificaDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			atividadeCientificaDAO.altera(atividadeCientifica);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Alterado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao alterar", null);
		}
		limparAtividadeCientifica();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void removerAtividadeCientifica() {

		AtividadeCientificaDAO atividadeCientificaDAO = new AtividadeCientificaDAO();
		try {
			atividadeCientificaDAO.delete(atividadeCientifica);
			limparAtividadeCientifica();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public List<Publicacao> getPublicacoes() {
		if (publicacoes == null) {
			PublicacaoDAO publicacaoDAO = new PublicacaoDAO();
			setPublicacoes(publicacaoDAO.publicacoesPorUsuario(usuario));
		}
		return publicacoes;
	}

	public void setPublicacoes(List<Publicacao> publicacoes) {
		this.publicacoes = publicacoes;
	}

	public void gravarPublicacao(ActionEvent actionEvent) {
		PublicacaoDAO publicacaoDAO = new PublicacaoDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			publicacao.setUsuario(usuario);
			publicacaoDAO.salva(publicacao);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Gravado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao gravar", null);
		}
		limparPublicacao();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void alterarPublicacao(ActionEvent actionEvent) {
		PublicacaoDAO publicacaoDAO = new PublicacaoDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			publicacaoDAO.altera(publicacao);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Alterado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao alterar", null);
		}
		limparPublicacao();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void removerPublicacao() {

		PublicacaoDAO publicacaoDAO = new PublicacaoDAO();
		try {
			publicacaoDAO.delete(publicacao);
			limparPublicacao();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public void gravarEndereco(ActionEvent actionEvent) {
		EnderecoDAO enderecoDAO = new EnderecoDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			endereco.setUsuario(usuario);
			enderecoDAO.cadastrar(endereco);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Gravado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao gravar", null);
		}
		limparEndereco();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void alterarEndereco(ActionEvent actionEvent) {
		EnderecoDAO enderecoDAO = new EnderecoDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			enderecoDAO.atualizar(endereco);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Alterado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao alterar", null);
		}
		limparEndereco();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void removerEndereco() {

		EnderecoDAO enderecoDAO = new EnderecoDAO();
		try {
			enderecoDAO.excluir(endereco);
			limparEndereco();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public Endereco getEnderecoUsuario() {
		if (enderecoUsuario.getId() == null) {
			EnderecoDAO dao = new EnderecoDAO();
			setEnderecoUsuario(dao.enderecoPorUsuario(usuario));
		}

		return enderecoUsuario;
	}

	public void setEnderecoUsuario(Endereco enderecoUsuario) {
		this.enderecoUsuario = enderecoUsuario;
	}

	public List<Telefone> getTelefones() {
		if (telefones == null) {
			TelefoneDAO telefoneDAO = new TelefoneDAO();
			setTelefones(telefoneDAO.telefonePorUsuario(usuario));
		}
		return telefones;
	}

	public void setTelefones(List<Telefone> telefones) {
		this.telefones = telefones;
	}

	public void gravarTelefone(ActionEvent actionEvent) {
		TelefoneDAO telefoneDAO = new TelefoneDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			telefone.setUsuario(usuario);
			telefoneDAO.cadastrar(telefone);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Gravado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao gravar", null);
		}
		limparTelefones();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void alterarTelefone(ActionEvent actionEvent) {
		TelefoneDAO telefoneDAO = new TelefoneDAO();
		RequestContext context = RequestContext.getCurrentInstance();
		FacesMessage msg = null;
		boolean gravado = false;

		try {
			telefoneDAO.atualizar(telefone);
			gravado = true;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Alterado com sucesso", null);

		} catch (Exception e) {
			e.printStackTrace();
			gravado = false;
			msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
					"Erro ao alterar", null);
		}
		limparTelefones();
		FacesContext.getCurrentInstance().addMessage(null, msg);
		context.addCallbackParam("gravado", gravado);
	}

	public void removerTelefone() {

		TelefoneDAO telefoneDAO = new TelefoneDAO();
		try {
			telefoneDAO.excluir(telefone);
			limparTelefones();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}
